package ca.csf.dfc.poo.environnement;

import java.util.Random;

import ca.csf.dfc.poo.exceptions.IllegalPositionXException;
import ca.csf.dfc.poo.exceptions.IllegalPositionYException;
import ca.csf.dfc.poo.exceptions.IllegalRecompenseException;
import ca.csf.dfc.poo.exceptions.IllegalTableauDecisionException;

/**
 * Classe d�finissant un robot qui se d�place toujours selon la r�compense imm�diate la plus �lev�e.
 * @author �quipe 1
 *
 */
public class RobotVorace extends Robot {

	/**
	 * Constructeur par initialisation recevant la position en x et y du robot.
	 * @param p_X : Position sur l'axe des abscisses.
	 * @param p_Y : Position sur l'axe des ordonn�es.
	 * @throws IllegalRecompenseException 
	 * @throws IllegalPositionYException 
	 * @throws IllegalPositionXException 
	 */
	public RobotVorace(int p_X, int p_Y) throws IllegalPositionXException, IllegalPositionYException, IllegalRecompenseException
	{
		super(p_X,p_Y);
	}

	/**
	 *  On prend une d�cision selon la case o� le robot peut se d�placer et qui a la r�compense la plus �lev�e.
	 *  @return La direction choisie.
	 * @throws IllegalTableauDecisionException 
	 * @see ca.csf.dfc.poo.environnement.Robot#prendreDecision(ca.csf.dfc.poo.environnement.Case, ca.csf.dfc.poo.environnement.Case, ca.csf.dfc.poo.environnement.Case, ca.csf.dfc.poo.environnement.Case)
	 */
	@Override
	public int prendreDecision(Case[] p_TabCases) throws IllegalTableauDecisionException {
	    
	  //On regarde si le tableau ne contient pas 4 cases.
        if (p_TabCases.length != 4)
            throw new IllegalTableauDecisionException();
	    
	    Random r = new Random();
	    
		int direction = AUCUNE;
		int recompense = AUCUNE;
		
		//On vérifie si on n'a a aucune direction dans laquelle aller.
		if ((p_TabCases[HAUT] == null) && (p_TabCases[DROITE] == null) && (p_TabCases[BAS] == null) && (p_TabCases[GAUCHE] == null))
		    return direction;
		
		boolean RecompensecasesIdentique = true;
		int tempR = AUCUNE;
		
		for (int dir = 0;dir<4;dir++)
		{
		    //Dans le cas ou on a pas encore de récompense
		    if ((p_TabCases[dir] != null) && (tempR == AUCUNE))
		    {
		        tempR = p_TabCases[dir].getRecompense();
		    }
		    else if ((p_TabCases[dir] != null) && (p_TabCases[dir].getRecompense() != tempR))
		    {
		        //Si on a une récompense qui est différente des autres
		        RecompensecasesIdentique = false;
		        break;
		    }
		}
		
		//On vérifie que toutes les directions ne sont pas nulles
		boolean toutesNulles = true;
		
		for(int i = 0;i<4;i++)
		{
		    if (p_TabCases[i] != null)
		    {
		        toutesNulles = false;
		        break;
		    }
		}
		
		//Lorsque tous les récompenses sont égales, on
		// faire un choix au hasard, seulement si les cases ne sont pas toutes nulles.
		if ((!toutesNulles) &&(RecompensecasesIdentique))
		{
		    boolean valide = false;
		    
		    while (!valide)
		    {
    		    //On génère un aléatoire pour aller dans une direction aléatoire au cas ou tous les direction
                //ont la même récompense.
                int dirHasard = r.nextInt(4);
                
                if (p_TabCases[dirHasard] != null)
                {
                    direction = dirHasard;
                    valide = true;
                }
		    }
		}
		else if (!toutesNulles)
		{
		    //Si les récompenses ne sont pas égales, on prend la plus grande
		    
		    //On boucle pour les 4 direction possibles
		    for(int dir = 0;dir<4;dir++)
		    {
		        if ((p_TabCases[dir] != null) && (p_TabCases[dir].getRecompense() > recompense))
		        {
		            direction = dir;
		            recompense = p_TabCases[dir].getRecompense();
		        }
		    }
		}
		return direction;	
	}
}
